package test.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import javolution.util.FastList;
import javolution.util.FastMap;

import org.junit.Test;


/**
 * @author lihongliang
 * 主要测试sun JDK1.7下ArrayList,LinkedList,HashMap,HashSet同Javolution5.5.1 下FastList,FastMap,FastSet对比
 * 本次测试环境是单线程环境，不考虑多线程，所以不测HashTable，Vector等等。
 * 为了避免GC对测试结果的影响，设置JVM参数：-Xms4096M -Xmx8192M-XX:+PrintGCDetails
 * 主要测试以下性能：
 *(1)ArrayList，LinkedList，FastList默认初始化容量add(i)，首位插入add(0,i)，首位删除remove(i)，随机查找get(i),迭代
 *(2)ArrayList，LinkedList，FastList设置初始化容量后的测试对比add（）
 *(3)HastMap，FastMap默认初始化容量put()，get()
 *(4)HastMap，FastMap设置初始化容量后put(),get()
 *(5)HashSet,FastSet的add(),iterator(),clear()
 *
 */
public class test1 {
	private int[] times={1,10,100,1000,10000,100000};

	public void listTest(int[] times,List list,int position){
		
		System.out.println(list.getClass().getName()+" add() test===========================");
		for(int i=0;i<times.length;i++){
			long startTime = System.nanoTime();
			for(int j=0;j<times[i];j++){
				list.add(position,j);
			}
			System.out.println(times[i]+":cost"+(System.nanoTime() - startTime)/1000+"us");
			//当数据为10万条时，测试get(),iterator(),remove(),clear()性能。
			if(times[i]==100000){
				System.out.println(list.getClass().getName()+" get() test===========================");
				int randomNum=(int)Math.random()*times[i];
				startTime=System.nanoTime();
				for(int t=0;t<times[i];t++){
					list.get(t);
				}
				System.out.println(times[i]+":cost"+(System.nanoTime() - startTime)/1000+"us");
				
				System.out.println(list.getClass().getName()+" iterator() test===========================");
				startTime=System.nanoTime();
				Iterator it=list.iterator();
				while(it.hasNext()){
					it.next();
				}
				System.out.println(times[i]+":cost"+(System.nanoTime() - startTime)/1000+"us");
				
				System.out.println(list.getClass().getName()+" remove() test===========================");
				startTime=System.nanoTime();
				list.remove(5000);
				System.out.println(times[i]+":cost"+(System.nanoTime() - startTime)/1000+"us");
				
				System.out.println(list.getClass().getName()+" clear() test===========================");
				startTime=System.nanoTime();
				list.clear();
				System.out.println(times[i]+":cost"+(System.nanoTime() - startTime)/1000+"us");
			}
		
		}
	}
	
	public void listTest(int[] times,List list){
		System.out.println(list.getClass().getName()+" add() test===========================");
		for(int i=0;i<times.length;i++){
			long startTime = System.nanoTime();
			for(int j=0;j<times[i];j++){
				list.add(j);
			}
			System.out.println(times[i]+":cost"+(System.nanoTime() - startTime)/1000);
			//当数据为10万条时，测试get(),iterator(),remove(),clear()性能。
			if(times[i]==100000){
				System.out.println(list.getClass().getName()+" get() test===========================");
				int randomNum=(int)Math.random()*times[i];
				startTime=System.nanoTime();
				for(int t=0;t<times[i];t++){
					list.get(t);
				}
				System.out.println(times[i]+":cost"+(System.nanoTime() - startTime)/1000+"us");
				
				System.out.println(list.getClass().getName()+" iterator() test===========================");
				startTime=System.nanoTime();
				Iterator it=list.iterator();
				while(it.hasNext()){
					it.next();
				}
				System.out.println(times[i]+":cost"+(System.nanoTime() - startTime)/1000+"us");
				
				System.out.println(list.getClass().getName()+" remove() test===========================");
				startTime=System.nanoTime();
				list.remove(5000);
				System.out.println(times[i]+":cost"+(System.nanoTime() - startTime)/1000+"us");
				
				System.out.println(list.getClass().getName()+" clear() test===========================");
				startTime=System.nanoTime();
				list.clear();
				System.out.println(times[i]+":cost"+(System.nanoTime() - startTime)/1000+"us");
			}
		}
	}
	
	
	
	/**
	 * list默认初始化容量的add()测试。
	 * 
	 */
//	@Test
	public void listAddTest1(){
		//最优情况下list插入，插入末尾
		/*listAddTest(times,new FastList());
		listAddTest(times,new ArrayList());
		listAddTest(times,new LinkedList());*/
		//最坏情况下list插入，插入首位
		listTest(times,new FastList(),0);
		listTest(times,new ArrayList(),0);
		listTest(times,new LinkedList(),0);
	}
	
	/**
	 * 设置list初始化容量为500000，保证list在插入时不会扩容
	 */
	
	public void listAddTest2(){
		//最优情况下list插入，插入末尾
		listTest(times,new FastList(1000000));
		listTest(times,new ArrayList(1000000));
		listTest(times,new LinkedList());
		
		//最坏情况下list插入，插入首位
		listTest(times,new FastList(1000000),0);
		listTest(times,new ArrayList(1000000),0);
		listTest(times,new LinkedList(),0);
	}
	
	
	public void mapTest(int[] times,Map map){
		System.out.println(map.getClass().getName()+" put() test===========================");
		long startTime;
		for(int i=0;i<times.length;i++){
			startTime=System.nanoTime();
			for(int j=0;j<times[i];j++){
				map.put(j, j);
			}
			System.out.println(times[i]+"cost:"+(System.nanoTime()-startTime)/1000);
			if(times[i]==100000){
				System.out.println(map.getClass().getName()+"get() test=========================");
				startTime=System.nanoTime();
				for(int t=0;t<times[i];t++){
					map.get(t);
				}
				System.out.println(times[i]+"cost:"+(System.nanoTime()-startTime)/1000);
			}
		}
	}
	@Test
	public void mapTest1(){
		mapTest(times,new HashMap());
		mapTest(times,new FastMap());
	}

	
}
